home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1998 / MacHack 1998.toast / Papers / C++ Exceptions / µShell / Array Classes / (Hidden) / DynamicArray.cp next >
Encoding:
Text File  |  1996-01-13  |  3.8 KB  |  157 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        DynamicArray.cp
  3.  
  4.     Contains:    A handle-based dynamic array class
  5.                 
  6.     Written by: Dave Falkenburg
  7.     
  8.     Copyright:    © 1994-95 by Dave Falkenburg, all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.      
  12.          <1>      1/3/95    DRF        First checked in.
  13.  */
  14.  
  15. #include "DynamicArray.h"
  16. #include <Memory.h>
  17.  
  18.  
  19. //--------------------------------------------------------------------------------
  20. TDynamicArray::TDynamicArray()
  21. {
  22.     fElementCount = 0;
  23.     fStorage = (ArrayElementPtr **) NewHandle(0);
  24. }
  25.     
  26.  
  27. //--------------------------------------------------------------------------------
  28. TDynamicArray::~TDynamicArray()
  29. {
  30.     DisposeHandle((Handle) fStorage);
  31. }
  32.     
  33.  
  34. //--------------------------------------------------------------------------------
  35. OSErr TDynamicArray::Insert(ArrayElement * elementToInsert, ArrayElementIndex beforeElement)
  36. {
  37.     OSErr    err;
  38.  
  39.     //    make room for one more ArrayElementPtr
  40.     SetHandleSize((Handle) fStorage, (fElementCount + 1) * sizeof(ArrayElementPtr));
  41.     if ((err = MemError()) != noErr)
  42.         return err;
  43.     
  44.     if(fElementCount){
  45.         //    slide remaining elements down
  46.         BlockMoveData(    &((*fStorage)[beforeElement]),
  47.                         &((*fStorage)[beforeElement+1]),
  48.                         (fElementCount - beforeElement) * sizeof(ArrayElementPtr));
  49.     }
  50.         
  51.     fElementCount++;
  52.     (*fStorage)[beforeElement] = elementToInsert;
  53.  
  54.     return noErr;
  55. }
  56.  
  57.  
  58. //--------------------------------------------------------------------------------
  59. OSErr TDynamicArray::InsertFirst(ArrayElement * elementToInsert)
  60. {
  61.     return this->Insert(elementToInsert,0);
  62. }
  63.  
  64.  
  65. //--------------------------------------------------------------------------------
  66. OSErr TDynamicArray::InsertLast(ArrayElement * elementToInsert)
  67. {
  68.     return this->Insert(elementToInsert,fElementCount);
  69. }
  70.  
  71.  
  72. //--------------------------------------------------------------------------------
  73. void TDynamicArray::Delete(ArrayElementIndex whichElement)
  74. {
  75.     //    slide remaining elements up
  76.     BlockMoveData(    &((*fStorage)[whichElement+1]),
  77.                     &((*fStorage)[whichElement]),
  78.                     (fElementCount - whichElement) * sizeof(ArrayElementPtr));
  79.  
  80.     //    cut back the storage
  81.     fElementCount--;
  82.     SetHandleSize((Handle) fStorage,fElementCount*sizeof(ArrayElementPtr));
  83. }
  84.  
  85.  
  86. //--------------------------------------------------------------------------------
  87. void TDynamicArray::DeleteFirst()
  88. {
  89.     this->Delete(0);
  90. }
  91.  
  92.  
  93. //--------------------------------------------------------------------------------
  94. void TDynamicArray::DeleteLast()
  95. {
  96.     this->Delete(fElementCount);
  97. }
  98.  
  99.  
  100. //--------------------------------------------------------------------------------
  101. ArrayElement * TDynamicArray::GetElementPtr(ArrayElementIndex whichElement)
  102. {    
  103.     return (*fStorage)[whichElement];
  104. }
  105.     
  106.  
  107. //--------------------------------------------------------------------------------
  108. void TDynamicArray::SetElementPtr(ArrayElementIndex whichElement, ArrayElementPtr element)
  109. {
  110.     (*fStorage)[whichElement] = element;
  111. }
  112.  
  113.  
  114. //--------------------------------------------------------------------------------
  115. void TDynamicArray::ForEachElement(EachArrayElementProc proc, void * param)
  116. {
  117.     ArrayElementIndex    index = 0;
  118.     
  119.     while (index < fElementCount)
  120.     {
  121.         (*proc)((*fStorage)[index],param);
  122.         index++;
  123.     }
  124. }
  125.  
  126.  
  127. //--------------------------------------------------------------------------------
  128. ArrayElement * TDynamicArray::FirstElementThat(EachArrayElementTestProc proc, void * param)
  129. {
  130.     ArrayElementIndex    index = 0;
  131.     
  132.     while (index < fElementCount)
  133.     {
  134.         if ((*proc)((*fStorage)[index],param))
  135.             return (*fStorage)[index];
  136.         index++;
  137.     }
  138.  
  139.     return NULL;
  140. }
  141.  
  142.  
  143. //--------------------------------------------------------------------------------
  144. ArrayElement * TDynamicArray::LastElementThat(EachArrayElementTestProc proc, void * param)
  145. {
  146.     ArrayElementIndex    index = fElementCount-1;
  147.     
  148.     while (index != -1)
  149.     {
  150.         if ((*proc)((*fStorage)[index],param))
  151.             return (*fStorage)[index];
  152.         index--;
  153.     }
  154.  
  155.     return NULL;
  156. }
  157.